import { ref, computed } from 'vue'

/**
 * 规格选择 Composable - 天猫式简单方案
 * 后端返回所有变体数据，前端直接匹配
 */
export function useSpecificationSelection(product, variants = null) {
  // 响应式状态
  const selectedSpecs = ref({})
  const selectedVariant = ref(null)
  const variantError = ref(null)
  const quantity = ref(1)

  // 初始化变体状态
  if (product.product_type === 'single') {
    // 单规格商品，创建一个虚拟的默认变体用于价格显示
    selectedVariant.value = {
      id: null, // 单规格商品没有变体ID
      name: product.name,
      price: product.price,
      compare_price: product.compare_price,
      discount_percentage: product.discount_percentage,
      stock_quantity: product.stock_quantity,
      is_active: product.is_active,
      is_default: true,
      attributes: {},
      attribute_values: []
    }
  } else {
    // 多规格商品，不设置默认变体，让用户自己选择
    selectedVariant.value = null
  }

  /**
   * 根据规格组合查找变体（简单匹配）
   */
  const findVariantBySpecs = (specs) => {
    const variantList = variants || product.variants || []
    
    if (!variantList || variantList.length === 0) {
      return null
    }

    // 遍历所有变体，找到匹配的
    for (const variant of variantList) {
      if (isVariantMatch(variant, specs)) {
        return variant
      }
    }
    
    return null
  }

  /**
   * 检查变体是否匹配规格
   */
  const isVariantMatch = (variant, specs) => {
    // 优先使用 attributeValues 数据（驼峰命名）
    if (variant.attributeValues && Array.isArray(variant.attributeValues)) {
      // 检查每个规格是否匹配
      for (const [specKey, specValue] of Object.entries(specs)) {
        const attributeValue = variant.attributeValues.find(
          item => item.attribute && item.attribute.name === specKey
        )
        
        if (!attributeValue || attributeValue.value !== specValue) {
          return false
        }
      }
      return true
    }
    
    // 兼容旧数据格式，使用 attribute_values 数据（下划线命名）
    if (variant.attribute_values && Array.isArray(variant.attribute_values)) {
      // 检查每个规格是否匹配
      for (const [specKey, specValue] of Object.entries(specs)) {
        const attributeValue = variant.attribute_values.find(
          item => item.attribute && item.attribute.name === specKey
        )
        
        if (!attributeValue || attributeValue.value !== specValue) {
          return false
        }
      }
      return true
    }
    
    // 兼容旧数据格式，使用 attributes 数据
    if (variant.attributes) {
      for (const [specKey, specValue] of Object.entries(specs)) {
        if (variant.attributes[specKey] !== specValue) {
          return false
        }
      }
      return true
    }

    return false
  }

  /**
   * 选择规格
   */
  const selectSpec = (specKey, option) => {
    console.log('selectSpec called:', { specKey, option })
    console.log('Current selectedSpecs before:', { ...selectedSpecs.value })
    
    selectedSpecs.value[specKey] = option
    
    console.log('Current selectedSpecs after:', { ...selectedSpecs.value })
    
    // 查找匹配的变体
    const variant = findVariantBySpecs(selectedSpecs.value)
    
    console.log('Found variant:', variant)
    
    if (variant) {
      selectedVariant.value = variant
      variantError.value = null
      quantity.value = 1
      console.log('Variant selected successfully')
    } else {
      selectedVariant.value = null
      variantError.value = '未找到匹配的变体'
      console.log('No matching variant found')
    }
  }

  /**
   * 当前价格（实时计算）
   */
  const currentPrice = computed(() => {
    if (selectedVariant.value) {
      return selectedVariant.value.price
    }
    return product.price || 0
  })

  /**
   * 当前原价
   */
  const currentOriginalPrice = computed(() => {
    if (selectedVariant.value) {
      return selectedVariant.value.compare_price
    }
    return product.original_price || 0
  })

  /**
   * 当前库存
   */
  const currentStock = computed(() => {
    if (selectedVariant.value) {
      return selectedVariant.value.stock_quantity || 0
    }
    return product.stock_quantity || 0
  })

  /**
   * 当前折扣百分比
   */
  const currentDiscountPercentage = computed(() => {
    if (selectedVariant.value) {
      return selectedVariant.value.discount_percentage
    }
    return product.discount_percentage
  })

  /**
   * 是否可以加入购物车
   */
  const canAddToCart = computed(() => {
    return selectedVariant.value && 
           selectedVariant.value.stock_quantity > 0 && 
           selectedVariant.value.is_active
  })

  /**
   * 加入购物车按钮文本
   */
  const addToCartButtonText = computed(() => {
    if (!selectedVariant.value) {
      return '请选择规格'
    }
    if (selectedVariant.value.stock_quantity === 0) {
      return '暂时缺货'
    }
    if (!selectedVariant.value.is_active) {
      return '暂时下架'
    }
    return '加入购物车'
  })

  /**
   * 立即购买按钮文本
   */
  const buyNowButtonText = computed(() => {
    if (!selectedVariant.value) {
      return '请选择规格'
    }
    if (selectedVariant.value.stock_quantity === 0) {
      return '暂时缺货'
    }
    if (!selectedVariant.value.is_active) {
      return '暂时下架'
    }
    return '立即购买'
  })

  /**
   * 获取规格选项的可用性
   */
  const getSpecOptionAvailability = (specKey, option) => {
    // 临时选择该选项
    const tempSpecs = { ...selectedSpecs.value, [specKey]: option }
    
    // 检查是否有匹配的变体
    const variant = findVariantBySpecs(tempSpecs)
    return variant && variant.stock_quantity > 0 && variant.is_active
  }

  /**
   * 获取规格选项的库存状态
   */
  const getSpecOptionStockStatus = (specKey, option) => {
    const variantList = variants || product.variants || []
    
    // 如果当前规格已经选择了这个选项，直接返回选中状态
    if (selectedSpecs.value[specKey] === option) {
      const variant = findVariantBySpecs(selectedSpecs.value)
      if (!variant) return 'unavailable'
      if (variant.stock_quantity === 0) return 'out_of_stock'
      if (variant.stock_quantity <= 5) return 'low_stock'
      return 'in_stock'
    }

    // 检查是否有任何变体包含这个选项
    const hasVariantWithOption = variantList.some(variant => {
      // 检查 attributeValues (驼峰命名)
      if (variant.attributeValues && Array.isArray(variant.attributeValues)) {
        return variant.attributeValues.some(item => 
          item.attribute && 
          item.attribute.name === specKey && 
          item.value === option
        )
      }
      
      // 检查 attribute_values (下划线命名)
      if (variant.attribute_values && Array.isArray(variant.attribute_values)) {
        return variant.attribute_values.some(item => 
          item.attribute && 
          item.attribute.name === specKey && 
          item.value === option
        )
      }
      
      return false
    })

    if (!hasVariantWithOption) return 'unavailable'

    // 检查临时规格组合是否有匹配的变体
    const tempSpecs = { ...selectedSpecs.value, [specKey]: option }
    const variant = findVariantBySpecs(tempSpecs)
    
    if (!variant) {
      // 如果临时组合没有匹配的变体，但选项存在，则检查是否有任何包含此选项的变体有库存
      const variantsWithOption = variantList.filter(v => {
        if (v.attributeValues && Array.isArray(v.attributeValues)) {
          return v.attributeValues.some(item => 
            item.attribute && 
            item.attribute.name === specKey && 
            item.value === option
          )
        }
        return false
      })

      if (variantsWithOption.length === 0) return 'unavailable'
      
      // 检查是否有任何包含此选项的变体有库存
      const hasStock = variantsWithOption.some(v => v.stock_quantity > 0 && v.is_active)
      return hasStock ? 'in_stock' : 'out_of_stock'
    }

    if (variant.stock_quantity === 0) return 'out_of_stock'
    if (variant.stock_quantity <= 5) return 'low_stock'
    return 'in_stock'
  }

  // 初始化验证（在函数定义后进行）
  if (product.product_type === 'single') {
    // 对于单规格产品，确保虚拟变体正确设置
    if (!selectedVariant.value) {
      selectedVariant.value = {
        id: product.id,
        name: product.name,
        price: product.price,
        compare_price: product.compare_price,
        discount_percentage: product.discount_percentage,
        stock_quantity: product.stock_quantity,
        is_active: product.is_active,
        is_default: true,
        attributes: {},
        attribute_values: []
      }
    }
  }
  // 多规格商品不设置默认变体，用户需要自己选择规格

  return {
    // 状态
    selectedSpecs,
    selectedVariant,
    variantError,
    quantity,
    
    // 计算属性
    currentPrice,
    currentOriginalPrice,
    currentStock,
    currentDiscountPercentage,
    canAddToCart,
    addToCartButtonText,
    buyNowButtonText,
    
    // 方法
    selectSpec,
    getSpecOptionAvailability,
    getSpecOptionStockStatus,
    
    // 工具方法
    findVariantBySpecs,
    isVariantMatch
  }
}